// 文件系统模块中文封装
const fs = require('fs');
const path = require('path');

/**
 * 异步读取文件内容
 * @param {string} 文件路径 - 文件的路径
 * @param {Object|string} 选项 - 选项对象或编码字符串
 * @param {Function} 回调函数 - 回调函数 (错误, 数据) => {}
 */
function 读取文件(文件路径, 选项, 回调函数) {
  return fs.readFile(文件路径, 选项, 回调函数);
}

/**
 * 同步读取文件内容
 * @param {string} 文件路径 - 文件的路径
 * @param {Object|string} 选项 - 选项对象或编码字符串
 * @returns {Buffer|string} 文件内容
 */
function 读取文件同步(文件路径, 选项) {
  return fs.readFileSync(文件路径, 选项);
}

/**
 * 异步写入文件内容
 * @param {string} 文件路径 - 文件的路径
 * @param {string|Buffer} 数据 - 要写入的数据
 * @param {Object|string} 选项 - 选项对象或编码字符串
 * @param {Function} 回调函数 - 回调函数 (错误) => {}
 */
function 写入文件(文件路径, 数据, 选项, 回调函数) {
  return fs.writeFile(文件路径, 数据, 选项, 回调函数);
}

/**
 * 同步写入文件内容
 * @param {string} 文件路径 - 文件的路径
 * @param {string|Buffer} 数据 - 要写入的数据
 * @param {Object|string} 选项 - 选项对象或编码字符串
 */
function 写入文件同步(文件路径, 数据, 选项) {
  return fs.writeFileSync(文件路径, 数据, 选项);
}

/**
 * 异步追加内容到文件
 * @param {string} 文件路径 - 文件的路径
 * @param {string|Buffer} 数据 - 要追加的数据
 * @param {Object|string} 选项 - 选项对象或编码字符串
 * @param {Function} 回调函数 - 回调函数 (错误) => {}
 */
function 追加文件(文件路径, 数据, 选项, 回调函数) {
  return fs.appendFile(文件路径, 数据, 选项, 回调函数);
}

/**
 * 同步追加内容到文件
 * @param {string} 文件路径 - 文件的路径
 * @param {string|Buffer} 数据 - 要追加的数据
 * @param {Object|string} 选项 - 选项对象或编码字符串
 */
function 追加文件同步(文件路径, 数据, 选项) {
  return fs.appendFileSync(文件路径, 数据, 选项);
}

/**
 * 异步读取目录内容
 * @param {string} 目录路径 - 目录的路径
 * @param {Object|string} 选项 - 选项对象或编码字符串
 * @param {Function} 回调函数 - 回调函数 (错误, 文件列表) => {}
 */
function 读取目录(目录路径, 选项, 回调函数) {
  return fs.readdir(目录路径, 选项, 回调函数);
}

/**
 * 同步读取目录内容
 * @param {string} 目录路径 - 目录的路径
 * @param {Object|string} 选项 - 选项对象或编码字符串
 * @returns {string[]|Buffer[]} 文件列表
 */
function 读取目录同步(目录路径, 选项) {
  return fs.readdirSync(目录路径, 选项);
}

/**
 * 异步创建目录
 * @param {string} 目录路径 - 目录的路径
 * @param {Object} 选项 - 选项对象
 * @param {Function} 回调函数 - 回调函数 (错误) => {}
 */
function 创建目录(目录路径, 选项, 回调函数) {
  return fs.mkdir(目录路径, 选项, 回调函数);
}

/**
 * 同步创建目录
 * @param {string} 目录路径 - 目录的路径
 * @param {Object} 选项 - 选项对象
 */
function 创建目录同步(目录路径, 选项) {
  return fs.mkdirSync(目录路径, 选项);
}

/**
 * 异步删除文件
 * @param {string} 文件路径 - 文件的路径
 * @param {Function} 回调函数 - 回调函数 (错误) => {}
 */
function 删除文件(文件路径, 回调函数) {
  return fs.unlink(文件路径, 回调函数);
}

/**
 * 同步删除文件
 * @param {string} 文件路径 - 文件的路径
 */
function 删除文件同步(文件路径) {
  return fs.unlinkSync(文件路径);
}

/**
 * 异步删除目录
 * @param {string} 目录路径 - 目录的路径
 * @param {Function} 回调函数 - 回调函数 (错误) => {}
 */
function 删除目录(目录路径, 回调函数) {
  return fs.rmdir(目录路径, 回调函数);
}

/**
 * 同步删除目录
 * @param {string} 目录路径 - 目录的路径
 */
function 删除目录同步(目录路径) {
  return fs.rmdirSync(目录路径);
}

/**
 * 异步删除文件或目录（支持递归删除）
 * @param {string} 路径 - 文件或目录的路径
 * @param {Object} 选项 - 选项对象
 * @param {Function} 回调函数 - 回调函数 (错误) => {}
 */
function 删除路径(路径, 选项, 回调函数) {
  return fs.rm(路径, 选项, 回调函数);
}

/**
 * 同步删除文件或目录（支持递归删除）
 * @param {string} 路径 - 文件或目录的路径
 * @param {Object} 选项 - 选项对象
 */
function 删除路径同步(路径, 选项) {
  return fs.rmSync(路径, 选项);
}

/**
 * 异步检查路径是否存在
 * @param {string} 路径 - 要检查的路径
 * @param {Function} 回调函数 - 回调函数 (错误, 存在) => {}
 */
function 路径是否存在(路径, 回调函数) {
  return fs.exists(路径, 回调函数);
}

/**
 * 同步检查路径是否存在
 * @param {string} 路径 - 要检查的路径
 * @returns {boolean} 路径是否存在
 */
function 路径是否存在同步(路径) {
  try {
    fs.accessSync(路径);
    return true;
  } catch (error) {
    return false;
  }
}

/**
 * 异步获取文件或目录信息
 * @param {string} 路径 - 文件或目录的路径
 * @param {Function} 回调函数 - 回调函数 (错误, 统计信息) => {}
 */
function 获取文件信息(路径, 回调函数) {
  return fs.stat(路径, 回调函数);
}

/**
 * 同步获取文件或目录信息
 * @param {string} 路径 - 文件或目录的路径
 * @returns {Object} 文件统计信息
 */
function 获取文件信息同步(路径) {
  return fs.statSync(路径);
}

/**
 * 异步重命名文件或目录
 * @param {string} 旧路径 - 旧路径
 * @param {string} 新路径 - 新路径
 * @param {Function} 回调函数 - 回调函数 (错误) => {}
 */
function 重命名(旧路径, 新路径, 回调函数) {
  return fs.rename(旧路径, 新路径, 回调函数);
}

/**
 * 同步重命名文件或目录
 * @param {string} 旧路径 - 旧路径
 * @param {string} 新路径 - 新路径
 */
function 重命名同步(旧路径, 新路径) {
  return fs.renameSync(旧路径, 新路径);
}

/**
 * 异步复制文件
 * @param {string} 源路径 - 源文件路径
 * @param {string} 目标路径 - 目标文件路径
 * @param {Object} 选项 - 选项对象
 * @param {Function} 回调函数 - 回调函数 (错误) => {}
 */
function 复制文件(源路径, 目标路径, 选项, 回调函数) {
  return fs.copyFile(源路径, 目标路径, 选项, 回调函数);
}

/**
 * 同步复制文件
 * @param {string} 源路径 - 源文件路径
 * @param {string} 目标路径 - 目标文件路径
 * @param {Object} 选项 - 选项对象
 */
function 复制文件同步(源路径, 目标路径, 选项) {
  return fs.copyFileSync(源路径, 目标路径, 选项);
}

/**
 * 获取路径的绝对路径
 * @param {string} 路径 - 相对路径或绝对路径
 * @returns {string} 绝对路径
 */
function 获取绝对路径(路径) {
  return path.resolve(路径);
}

/**
 * 连接路径片段
 * @param {...string} 路径片段 - 要连接的路径片段
 * @returns {string} 连接后的路径
 */
function 连接路径(...路径片段) {
  return path.join(...路径片段);
}

/**
 * 获取路径的目录名
 * @param {string} 路径 - 文件或目录的路径
 * @returns {string} 目录名
 */
function 获取目录名(路径) {
  return path.dirname(路径);
}

/**
 * 获取路径的文件名
 * @param {string} 路径 - 文件的路径
 * @param {boolean} 包含扩展名 - 是否包含扩展名
 * @returns {string} 文件名
 */
function 获取文件名(路径, 包含扩展名 = true) {
  return path.basename(路径, 包含扩展名 ? undefined : path.extname(路径));
}

/**
 * 获取路径的扩展名
 * @param {string} 路径 - 文件的路径
 * @returns {string} 扩展名
 */
function 获取扩展名(路径) {
  return path.extname(路径);
}

module.exports = {
  读取文件,
  读取文件同步,
  写入文件,
  写入文件同步,
  追加文件,
  追加文件同步,
  读取目录,
  读取目录同步,
  创建目录,
  创建目录同步,
  删除文件,
  删除文件同步,
  删除目录,
  删除目录同步,
  删除路径,
  删除路径同步,
  路径是否存在,
  路径是否存在同步,
  获取文件信息,
  获取文件信息同步,
  重命名,
  重命名同步,
  复制文件,
  复制文件同步,
  获取绝对路径,
  连接路径,
  获取目录名,
  获取文件名,
  获取扩展名
};